// 初始化ECharts实例
let myChart = null;
let myChart2 = null;

// WebSocket相关全局变量
let websocket = null;
let isConnected = false;

// 无人机库相关全局变量
let globalUavLib = [];
let globalUavNames = [];

// 无人机检测计数相关全局变量
let uavDetectionCounts = {}; // 存储每个位置点的检测次数（用于热力图显示）
let maxDetectionCount = 1000; // 最大检测次数，达到后清除数据（适应更大的检测范围）
let actualFreqMap = {}; // 存储每个位置点的实际检出频点列表
let freqDetectionCounts = {}; // 存储每个具体频点的检测次数（用于表格显示）
let freqSimilaritySums = {}; // 存储每个具体频点的Similarity总和（用于计算平均值）

// 定时器相关全局变量
let updateTimer = null; // 定时更新定时器
let updateInterval = 5000; // 更新间隔，默认5秒
let tableUpdateTimer = null; // 表格更新定时器

// Perlin噪声辅助函数
function getNoiseHelper() {
    class Grad {
        constructor(x, y, z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }
        dot2(x, y) {
            return this.x * x + this.y * y;
        }
        dot3(x, y, z) {
            return this.x * x + this.y * y + this.z * z;
        }
    }
    const grad3 = [
        new Grad(1, 1, 0),
        new Grad(-1, 1, 0),
        new Grad(1, -1, 0),
        new Grad(-1, -1, 0),
        new Grad(1, 0, 1),
        new Grad(-1, 0, 1),
        new Grad(1, 0, -1),
        new Grad(-1, 0, -1),
        new Grad(0, 1, 1),
        new Grad(0, -1, 1),
        new Grad(0, 1, -1),
        new Grad(0, -1, -1)
    ];
    const p = [
        151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140,
        36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120,
        234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33,
        88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71,
        134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133,
        230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161,
        1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200, 196, 135, 130,
        116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250,
        124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227,
        47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44,
        154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98,
        108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34,
        242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249, 14,
        239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121,
        50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243,
        141, 128, 195, 78, 66, 215, 61, 156, 180
    ];
    // To remove the need for index wrapping, double the permutation table length
    let perm = new Array(512);
    let gradP = new Array(512);
    // This isn't a very good seeding function, but it works ok. It supports 2^16
    // different seed values. Write something better if you need more seeds.
    function seed(seed) {
        if (seed > 0 && seed < 1) {
            // Scale the seed out
            seed *= 65536;
        }
        seed = Math.floor(seed);
        if (seed < 256) {
            seed |= seed << 8;
        }
        for (let i = 0; i < 256; i++) {
            let v;
            if (i & 1) {
                v = p[i] ^ (seed & 255);
            } else {
                v = p[i] ^ ((seed >> 8) & 255);
            }
            perm[i] = perm[i + 256] = v;
            gradP[i] = gradP[i + 256] = grad3[v % 12];
        }
    }
    seed(0);
    // ##### Perlin noise stuff
    function fade(t) {
        return t * t * t * (t * (t * 6 - 15) + 10);
    }
    function lerp(a, b, t) {
        return (1 - t) * a + t * b;
    }
    // 2D Perlin Noise
    function perlin2(x, y) {
        // Find unit grid cell containing point
        let X = Math.floor(x),
            Y = Math.floor(y);
        // Get relative xy coordinates of point within that cell
        x = x - X;
        y = y - Y;
        // Wrap the integer cells at 255 (smaller integer period can be introduced here)
        X = X & 255;
        Y = Y & 255;
        // Calculate noise contributions from each of the four corners
        let n00 = gradP[X + perm[Y]].dot2(x, y);
        let n01 = gradP[X + perm[Y + 1]].dot2(x, y - 1);
        let n10 = gradP[X + 1 + perm[Y]].dot2(x - 1, y);
        let n11 = gradP[X + 1 + perm[Y + 1]].dot2(x - 1, y - 1);
        // Compute the fade curve value for x
        let u = fade(x);
        // Interpolate the four results
        return lerp(lerp(n00, n10, u), lerp(n01, n11, u), fade(y));
    }
    return {
        seed,
        perlin2
    };
}

// 生成Perlin噪声数据
function generatePerlinData() {
    let noise = getNoiseHelper();
    let xData = [];
    let yData = [];
    noise.seed(Math.random());
    
    // 生成横坐标数据：从300到6000，每5为一个点
    for (let x = 300; x <= 6000; x += 5) {
        xData.push(x);
    }
    
    function generateData(theta, min, max) {
        let data = [];
        // 使用无人机名称作为纵坐标，如果没有则使用默认值
        if (globalUavNames && globalUavNames.length > 0) {
            yData = globalUavNames;
        } else {
            // 生成默认纵坐标数据：从1到47
            for (let y = 1; y <= 47; y++) {
                yData.push(y);
            }
        }
        
        for (let i = 0; i < xData.length; i++) {
            for (let j = 0; j < yData.length; j++) {
                // 检查是否有检测数据
                const key = `${i}_${j}`;
                if (uavDetectionCounts[key] && uavDetectionCounts[key] > 0) {
                    // 使用统一的归一化函数
                    const normalizedValue = normalizeDetectionCount(uavDetectionCounts[key]);
                    data.push([i, j, normalizedValue]);
                } else {
                    // 使用Perlin噪声作为默认值
                    data.push([i, j, noise.perlin2(i / 40, j / 20) + 0.5]);
                }
            }
        }
        return data;
    }
    
    return {
        data: generateData(2, -5, 5),
        xData: xData,
        yData: yData
    };
}

// 初始化热力图
function initHeatmap() {
    const chartDom = document.getElementById('heatmap');
    myChart = echarts.init(chartDom);
    
    const chartDom2 = document.getElementById('heatmap2');
    myChart2 = echarts.init(chartDom2);
    
    const perlinData1 = generateEmptyData1();
    const perlinData2 = generateEmptyData2();
    
    // 将perlinData存储为全局变量以便tooltip使用
    window.currentPerlinData1 = perlinData1;
    window.currentPerlinData2 = perlinData2;
    
    const option1 = {
        backgroundColor: '#fafafa',
        title: {
            text: '无人机检出热力图 (0-3000MHz)',
            left: 'center',
            textStyle: {
                fontSize: 18,
                fontWeight: 'bold',
                color: '#333'
            }
        },
        tooltip: {
            position: 'top',
            backgroundColor: 'rgba(0,0,0,0.8)',
            borderColor: '#fff',
            borderWidth: 1,
            textStyle: {
                color: '#fff'
            },
            formatter: function(params) {
                const xValue = window.currentPerlinData1.xData[params.data[0]];
                const yValue = window.currentPerlinData1.yData[params.data[1]];
                const key = `1_${params.data[0]}_${params.data[1]}`;
                const detectionCount = uavDetectionCounts[key] || 0;
                
                if (detectionCount > 0) {
                    return `频率: ${xValue} MHz<br/>无人机: ${yValue}<br/>检测次数: ${detectionCount}次`;
                } else {
                    return `频率: ${xValue} MHz<br/>无人机: ${yValue}<br/>状态: 无检测`;
                }
            }
        },
        grid: {
            height: '85%',
            top: '5%',
            left: '6%',
            right: '1%'
        },
        xAxis: {
            type: 'category',
            data: perlinData1.xData,
            splitArea: {
                show: true
            },
            axisLabel: {
                show: true,
                fontSize: 10,
                color: '#666',
                interval: Math.floor(perlinData1.xData.length / 10) // 显示部分标签避免拥挤
            },
            axisTick: {
                show: false
            },
            axisLine: {
                show: false
            }
        },
        yAxis: {
            type: 'category',
            data: perlinData1.yData,
            splitArea: {
                show: true
            },
            axisLabel: {
                fontSize: 12,
                color: '#666'
            },
            axisTick: {
                show: false
            },
            axisLine: {
                show: false
            }
        },
        visualMap: {
            min: 0,
            max: 1,
            calculable: true, // 启用拖动功能
            range: [0, 1], // 设置拖动范围，上限固定
            orient: 'horizontal',
            left: 'center',
            bottom: '1%',
            itemWidth: 20,
            itemHeight: 300,
            textStyle: {
                fontSize: 12
            },
            inRange: {
                color: [
                    '#ffffff',  // 白色（无检测）
                    '#4fc3f7',  // 浅蓝色
                    '#2196f3',  // 蓝色
                    '#1976d2',  // 深蓝色
                    '#0d47a1',  // 更深的蓝色
                    '#ffeb3b',  // 黄色
                    '#ff9800',  // 橙色
                    '#ff5722',  // 深橙色
                    '#f44336',  // 红色
                    '#d32f2f',  // 深红色
                    '#b71c1c'   // 最深的红色
                ]
            },
            // 添加动态更新支持
            realtime: true,
            precision: 0,
            // 禁用鼠标悬停动态显示
            hoverLink: false,
            // 显示最大值和最小值
            show: true,
            text: ['1次', '0次'],
            textGap: 10
        },
        series: [{
            name: 'Perlin噪声',
            type: 'heatmap',
            data: perlinData1.data,
            label: {
                show: false
            },
            itemStyle: {
                borderWidth: 0.5,
                borderColor: '#f0f0f0'
            },
            emphasis: {
                itemStyle: {
                    shadowBlur: 10,
                    shadowColor: 'rgba(0, 0, 0, 0.5)',
                    borderWidth: 2,
                    borderColor: '#333'
                }
            },
            progressive: 1000,
            animation: false,
            animationDuration: 0,
            animationEasing: 'linear'
        }]
    };
    
    const option2 = {
        backgroundColor: '#fafafa',
        title: {
            text: '无人机检出热力图 (3000-6000MHz)',
            left: 'center',
            textStyle: {
                fontSize: 18,
                fontWeight: 'bold',
                color: '#333'
            }
        },
        tooltip: {
            position: 'top',
            backgroundColor: 'rgba(0,0,0,0.8)',
            borderColor: '#fff',
            borderWidth: 1,
            textStyle: {
                color: '#fff'
            },
            formatter: function(params) {
                const xValue = window.currentPerlinData2.xData[params.data[0]];
                const yValue = window.currentPerlinData2.yData[params.data[1]];
                const key = `2_${params.data[0]}_${params.data[1]}`;
                const detectionCount = uavDetectionCounts[key] || 0;
                
                if (detectionCount > 0) {
                    return `频率: ${xValue} MHz<br/>无人机: ${yValue}<br/>检测次数: ${detectionCount}次`;
                } else {
                    return `频率: ${xValue} MHz<br/>无人机: ${yValue}<br/>状态: 无检测`;
                }
            }
        },
        grid: {
            height: '85%',
            top: '5%',
            left: '6%',
            right: '1%'
        },
        xAxis: {
            type: 'category',
            data: perlinData2.xData,
            splitArea: {
                show: true
            },
            axisLabel: {
                show: true,
                fontSize: 10,
                color: '#666',
                interval: Math.floor(perlinData2.xData.length / 10) // 显示部分标签避免拥挤
            },
            axisTick: {
                show: false
            },
            axisLine: {
                show: false
            }
        },
        yAxis: {
            type: 'category',
            data: perlinData2.yData,
            splitArea: {
                show: true
            },
            axisLabel: {
                fontSize: 12,
                color: '#666'
            },
            axisTick: {
                show: false
            },
            axisLine: {
                show: false
            }
        },
        visualMap: {
            min: 0,
            max: 1,
            calculable: true, // 启用拖动功能
            range: [0, 1], // 设置拖动范围，上限固定
            orient: 'horizontal',
            left: 'center',
            bottom: '1%',
            itemWidth: 20,
            itemHeight: 300,
            textStyle: {
                fontSize: 12
            },
            inRange: {
                color: [
                    '#ffffff',  // 白色（无检测）
                    '#4fc3f7',  // 浅蓝色
                    '#2196f3',  // 蓝色
                    '#1976d2',  // 深蓝色
                    '#0d47a1',  // 更深的蓝色
                    '#ffeb3b',  // 黄色
                    '#ff9800',  // 橙色
                    '#ff5722',  // 深橙色
                    '#f44336',  // 红色
                    '#d32f2f',  // 深红色
                    '#b71c1c'   // 最深的红色
                ]
            },
            // 添加动态更新支持
            realtime: true,
            precision: 0,
            // 禁用鼠标悬停动态显示
            hoverLink: false,
            // 显示最大值和最小值
            show: true,
            text: ['1次', '0次'],
            textGap: 10
        },
        series: [{
            name: 'Perlin噪声',
            type: 'heatmap',
            data: perlinData2.data,
            label: {
                show: false
            },
            itemStyle: {
                borderWidth: 0.5,
                borderColor: '#f0f0f0'
            },
            emphasis: {
                itemStyle: {
                    shadowBlur: 10,
                    shadowColor: 'rgba(0, 0, 0, 0.5)',
                    borderWidth: 2,
                    borderColor: '#333'
                }
            },
            progressive: 1000,
            animation: false,
            animationDuration: 0,
            animationEasing: 'linear'
        }]
    };
    
    myChart.setOption(option1);
    myChart2.setOption(option2);
    
    // 监听第一个热力图的拖动条变化事件，限制只能拖动下限
    myChart.on('dataRangeSelected', function(params) {
        console.log('🎛️ 用户拖动第一个热力图拖动条:', params);
        
        // 获取当前拖动条设置
        const currentOption = myChart.getOption();
        const visualMap = currentOption.visualMap[0];
        
        // 如果用户试图拖动上限，则恢复到原来的上限，但保持用户设置的下限
        if (params.range[1] !== visualMap.max) {
            console.log('⚠️ 检测到用户试图拖动上限，已阻止');
            myChart.setOption({
                visualMap: {
                    range: [params.range[0], visualMap.max] // 保持用户设置的下限，上限固定
                }
            });
            // 同步第二个热力图
            myChart2.setOption({
                visualMap: {
                    range: [params.range[0], visualMap.max]
                }
            });
        } else {
            // 用户只拖动了下限，记录新的下限设置
            console.log('✅ 用户设置下限为:', Math.round(params.range[0]));
            // 同步第二个热力图
            myChart2.setOption({
                visualMap: {
                    range: [params.range[0], visualMap.max]
                }
            });
        }
    });
    
    // 监听第二个热力图的拖动条变化事件，限制只能拖动下限
    myChart2.on('dataRangeSelected', function(params) {
        console.log('🎛️ 用户拖动第二个热力图拖动条:', params);
        
        // 获取当前拖动条设置
        const currentOption = myChart2.getOption();
        const visualMap = currentOption.visualMap[0];
        
        // 如果用户试图拖动上限，则恢复到原来的上限，但保持用户设置的下限
        if (params.range[1] !== visualMap.max) {
            console.log('⚠️ 检测到用户试图拖动上限，已阻止');
            myChart2.setOption({
                visualMap: {
                    range: [params.range[0], visualMap.max] // 保持用户设置的下限，上限固定
                }
            });
            // 同步第一个热力图
            myChart.setOption({
                visualMap: {
                    range: [params.range[0], visualMap.max]
                }
            });
        } else {
            // 用户只拖动了下限，记录新的下限设置
            console.log('✅ 用户设置下限为:', Math.round(params.range[0]));
            // 同步第一个热力图
            myChart.setOption({
                visualMap: {
                    range: [params.range[0], visualMap.max]
                }
            });
        }
    });
    

}



// 清空数据
function clearData() {
    console.log('🧹 开始清空所有检测数据...');
    
    // 显示清空前的数据统计
    let totalDetections = 0;
    let activeDetections = 0;
    for (const key in uavDetectionCounts) {
        if (uavDetectionCounts[key] > 0) {
            activeDetections++;
            totalDetections += uavDetectionCounts[key];
        }
    }
    
    if (activeDetections > 0) {
        console.log(`📊 清空前统计: ${activeDetections}个活跃检测点，共${totalDetections}次检测`);
    }
    
    // 清空检测计数和实际频点映射
    uavDetectionCounts = {};
    actualFreqMap = {};
    freqDetectionCounts = {};
    freqSimilaritySums = {};
    
    // 生成空白数据
    const perlinData1 = generateEmptyData1();
    const perlinData2 = generateEmptyData2();
    
    // 更新全局变量
    window.currentPerlinData1 = perlinData1;
    window.currentPerlinData2 = perlinData2;
    
    // 更新图表
    myChart.setOption({
        visualMap: {
            min: 0,
            max: 1,
            precision: 0, // 确保显示整数，不显示小数
            text: ['1次', '0次']
        },
        series: [{
            data: perlinData1.data
        }]
    });
    
    // 同步更新第二个热力图
    myChart2.setOption({
        visualMap: {
            min: 0,
            max: 1,
            precision: 0, // 确保显示整数，不显示小数
            text: ['1次', '0次']
        },
        series: [{
            data: perlinData2.data
        }]
    });
    


    
    // 更新表格显示
    updateDetectionTable();
    
    console.log('✅ 所有检测数据已成功清除');
    console.log('🔄 热力图已重置为空白状态');
    console.log('📊 检出统计表已清空');
}

// 生成第一个热力图的空白数据（0-3000Hz）
function generateEmptyData1() {
    let xData = [];
    let yData = [];
    
    // 生成横坐标数据：从0到3000MHz，每5MHz为一个点
    for (let x = 0; x <= 3000; x += 5) {
        xData.push(x);
    }
    
    console.log(`🔍 热力图1横坐标数据: 长度=${xData.length}, 范围=${xData[0]}-${xData[xData.length-1]} Hz`);
    
    // 使用无人机名称作为纵坐标，如果没有则使用默认值
    if (globalUavNames && globalUavNames.length > 0) {
        yData = globalUavNames;
    } else {
        // 生成默认纵坐标数据：从1到47
        for (let y = 1; y <= 47; y++) {
            yData.push(y);
        }
    }
    
    // 生成初始数据（所有值都为0，等待检测数据）
    let data = [];
    for (let i = 0; i < xData.length; i++) {
        for (let j = 0; j < yData.length; j++) {
            // 检查是否有检测数据
            const key = `1_${i}_${j}`;
            if (uavDetectionCounts[key] && uavDetectionCounts[key] > 0) {
                // 使用统一的归一化函数
                const normalizedValue = normalizeDetectionCount(uavDetectionCounts[key]);
                data.push([i, j, normalizedValue]);
            } else {
                // 无检测数据时为0
                data.push([i, j, 0]);
            }
        }
    }
    
    return {
        data: data,
        xData: xData,
        yData: yData
    };
}

// 生成第二个热力图的空白数据（3000-6000Hz）
function generateEmptyData2() {
    let xData = [];
    let yData = [];
    
    // 生成横坐标数据：从3000到6000MHz，每5MHz为一个点
    for (let x = 3000; x <= 6000; x += 5) {
        xData.push(x);
    }
    
    console.log(`🔍 热力图2横坐标数据: 长度=${xData.length}, 范围=${xData[0]}-${xData[xData.length-1]} Hz`);
    
    // 使用无人机名称作为纵坐标，如果没有则使用默认值
    if (globalUavNames && globalUavNames.length > 0) {
        yData = globalUavNames;
    } else {
        // 生成默认纵坐标数据：从1到47
        for (let y = 1; y <= 47; y++) {
            yData.push(y);
        }
    }
    
    // 生成初始数据（所有值都为0，等待检测数据）
    let data = [];
    for (let i = 0; i < xData.length; i++) {
        for (let j = 0; j < yData.length; j++) {
            // 检查是否有检测数据
            const key = `2_${i}_${j}`;
            if (uavDetectionCounts[key] && uavDetectionCounts[key] > 0) {
                // 使用统一的归一化函数
                const normalizedValue = normalizeDetectionCount(uavDetectionCounts[key]);
                data.push([i, j, normalizedValue]);
            } else {
                // 无检测数据时为0
                data.push([i, j, 0]);
            }
        }
    }
    
    return {
        data: data,
        xData: xData,
        yData: yData
    };
}



// WebSocket连接功能
function connectWebSocket() {
    const ip = document.getElementById('wsIp').value.trim();
    const port = document.getElementById('wsPort').value.trim();
    
    if (!ip || !port) {
        alert('请输入IP地址和端口号');
        return;
    }
    
    const wsUrl = `ws://${ip}:${port}`;
    
    try {
        websocket = new WebSocket(wsUrl);
        updateConnectionStatus('connecting', '连接中');
        
        websocket.onopen = function(event) {
            isConnected = true;
            updateConnectionStatus('connected', '已连接');
            updateButtonStates(true);
            console.log('WebSocket连接已建立');
        };
        
        websocket.onmessage = function(event) {
            try {
                const jsonData = JSON.parse(event.data);
                handleWebSocketData(jsonData);
            } catch (error) {
                console.error('解析WebSocket数据失败:', error);
            }
        };
        
        websocket.onclose = function(event) {
            isConnected = false;
            updateConnectionStatus('disconnected', '已断开');
            updateButtonStates(false);
            console.log('WebSocket连接已关闭');
        };
        
        websocket.onerror = function(error) {
            isConnected = false;
            updateConnectionStatus('disconnected', '连接失败');
            updateButtonStates(false);
            console.error('WebSocket连接错误:', error);
        };
        
    } catch (error) {
        console.error('创建WebSocket连接失败:', error);
        updateConnectionStatus('disconnected', '连接失败');
    }
}

function disconnectWebSocket() {
    if (websocket) {
        websocket.close();
        websocket = null;
    }
    isConnected = false;
    updateConnectionStatus('disconnected', '未连接');
    updateButtonStates(false);
}

function updateConnectionStatus(status, text) {
    const statusElement = document.getElementById('connectionStatus');
    statusElement.textContent = text;
    statusElement.className = `status-${status}`;
}

function updateButtonStates(connected) {
    const connectBtn = document.getElementById('connectBtn');
    const disconnectBtn = document.getElementById('disconnectBtn');
    const ipInput = document.getElementById('wsIp');
    const portInput = document.getElementById('wsPort');
    
    connectBtn.disabled = connected;
    disconnectBtn.disabled = !connected;
    ipInput.disabled = connected;
    portInput.disabled = connected;
}

function sendWebSocketMessage(message) {
    if (websocket && isConnected) {
        websocket.send(message);
    } else {
        console.warn('WebSocket未连接，无法发送消息');
    }
}

// 设置工作模式函数
function setWorkMode(mode) {
    var setModeMsg = {
        "msg": "setWorkMode",
        "mode": mode
    };
    sendWebSocketMessage(JSON.stringify(setModeMsg));
    console.log(`🔧 已发送工作模式设置: ${mode}`);
}

// 处理无人机检测数据
function handleUavObject(data) {
    console.log('🎯 检测到无人机:', data);
    
    // 获取无人机名称（直接从data对象中获取）
    const uavName = data.name;
    
    if (!uavName) {
        console.log('❌ 无人机数据中没有名称信息');
        console.log('可用的字段:', Object.keys(data));
        return;
    }

    const uavFreq = data.freq;
    
    if (!uavFreq) {
        console.log('❌ 无人机数据中没有频率信息');
        return;
    }
    
    // 根据频点大小选择在哪个热力图中更新
    let chartType = '';
    let freqIndex = -1;
    
    // 将频点转换为MHz进行判断
    const freqMHz = uavFreq / 1000;
    
    if (freqMHz < 3000) {
        // 频点小于3000MHz，在第一个热力图中更新
        chartType = '1';
        freqIndex = findNearestFrequencyIndex1(freqMHz);
        console.log(`📊 频点 ${freqMHz}MHz < 3000MHz，将在第一个热力图中更新`);
    } else {
        // 频点大于等于3000MHz，在第二个热力图中更新
        chartType = '2';
        freqIndex = findNearestFrequencyIndex2(freqMHz);
        console.log(`📊 频点 ${freqMHz}MHz >= 3000MHz，将在第二个热力图中更新`);
    }
    
    if (freqIndex === -1) {
        console.log(`❌ 无法匹配频率 ${freqMHz}MHz`);
        return;
    }
    
    // 查找无人机名称在纵坐标中的索引
    const uavIndex = globalUavNames.indexOf(uavName);
    if (uavIndex === -1) {
        console.log(`❌ 无法找到无人机名称: ${uavName}`);
        console.log('可用的无人机名称:', globalUavNames);
        return;
    }
    
    // 更新检测计数（用于热力图显示）
    const key = `${chartType}_${freqIndex}_${uavIndex}`;
    if (!uavDetectionCounts[key]) {
        uavDetectionCounts[key] = 0;
    }
    uavDetectionCounts[key]++;
    
    // 记录实际检出频点
    if (!actualFreqMap[key]) {
        actualFreqMap[key] = new Set();
    }
    actualFreqMap[key].add(uavFreq);
    
    // 记录每个具体频点的检测次数和Similarity值（用于表格显示）
    // 使用特殊分隔符避免无人机名称中的下划线造成歧义
    // 将频点除以1000转换为正确的MHz值
    const freqKey = `${uavName}|||${uavFreq / 1000}`;
    if (!freqDetectionCounts[freqKey]) {
        freqDetectionCounts[freqKey] = 0;
    }
    freqDetectionCounts[freqKey]++;
    
    // 记录Similarity值用于计算平均值
    if (!freqSimilaritySums[freqKey]) {
        freqSimilaritySums[freqKey] = 0;
    }
    // 从data中获取Similarity值，如果没有则默认为0
    const similarity = data.Similarity || 0;
    freqSimilaritySums[freqKey] += similarity;
    
    console.log(`📊 频点检测记录: ${freqKey} = ${freqDetectionCounts[freqKey]}次`);
    console.log(`📊 当前freqDetectionCounts总数量: ${Object.keys(freqDetectionCounts).length}`);
    console.log(`📊 当前Similarity值: ${similarity}, 累计总和: ${freqSimilaritySums[freqKey]}`);
    
    console.log(`✅ 保存检测信息: 热力图${chartType}, 频率索引=${freqIndex}, 无人机索引=${uavIndex}, 计数=${uavDetectionCounts[key]}`);
    console.log(`📡 实际检出频点: ${uavFreq} (原始值), ${uavFreq / 1000}MHz (转换后)`);
    console.log(`📊 频点 ${uavFreq / 1000}MHz 的检出次数: ${freqDetectionCounts[freqKey]}`);
    console.log('💾 检测信息已保存，等待定时更新显示...');
    
    // 检查是否达到最大检测次数（只记录日志，不自动清除）
    if (uavDetectionCounts[key] >= maxDetectionCount) {
        console.log('🔥 达到最大检测次数，但不会自动清除数据');
        console.log('💡 如需清除数据，请手动点击"清空数据"按钮');
        // 不再自动清除，让用户手动控制
        // clearData();
        // return;
    }
    
    // 数据已保存，等待定时器更新显示
    console.log('💾 检测数据已保存，等待定时器更新显示');
    
    // 如果定时更新没有启动，则自动启动
    if (!updateTimer) {
        console.log('🚀 检测到数据，自动启动定时更新');
        startAutoUpdate();
    }
}

// 更新单个格子
function updateSingleGrid(freqIndex, uavIndex, detectionCount) {
    if (!myChart) {
        console.log('❌ 图表实例不存在');
        return;
    }
    
    // 使用统一的归一化函数
    const normalizedValue = normalizeDetectionCount(detectionCount);
    
    // 计算数据索引
    const dataIndex = freqIndex * window.currentPerlinData.yData.length + uavIndex;
    
    console.log(`🔍 调试信息:`);
    console.log(`  - 频率索引: ${freqIndex}`);
    console.log(`  - 无人机索引: ${uavIndex}`);
    console.log(`  - 检测次数: ${detectionCount}`);
    console.log(`  - 归一化值: ${normalizedValue}`);
    console.log(`  - 数据索引: ${dataIndex}`);
    console.log(`  - 纵坐标长度: ${window.currentPerlinData.yData.length}`);
    
    // 获取当前图表的数据
    const currentData = myChart.getOption().series[0].data;
    console.log(`  - 当前数据长度: ${currentData.length}`);
    
    if (dataIndex >= 0 && dataIndex < currentData.length) {
        // 创建新的数据数组，只修改特定点
        const newData = [...currentData];
        const oldValue = newData[dataIndex][2];
        newData[dataIndex] = [freqIndex, uavIndex, normalizedValue];
        
        console.log(`  - 旧值: ${oldValue}`);
        console.log(`  - 新值: ${normalizedValue}`);
        
        // 强制更新图表
        myChart.setOption({
            series: [{
                data: newData
            }]
        }, {
            notMerge: false,
            lazyUpdate: false,  // 立即更新
            silent: false,  // 允许动画以显示更新效果
            animation: true  // 启用动画以显示更新
        });
        
        console.log(`✅ 更新格子 [${freqIndex}, ${uavIndex}] 为 ${normalizedValue.toFixed(3)}`);
        
        // 验证更新是否成功
        setTimeout(() => {
            const updatedData = myChart.getOption().series[0].data;
            const actualValue = updatedData[dataIndex][2];
            console.log(`🔍 验证更新: 实际值 = ${actualValue}`);
        }, 100);
        
    } else {
        console.log(`❌ 数据索引超出范围: ${dataIndex}, 数据长度: ${currentData.length}`);
    }
}

// 直接返回检测次数，不进行归一化
function normalizeDetectionCount(detectionCount) {
    // 直接返回检测次数，让ECharts的visualMap来处理颜色映射
    return detectionCount;
}





// 查找第一个热力图中最近的频率索引（0-3000Hz）
function findNearestFrequencyIndex1(targetFreq) {
    if (!window.currentPerlinData1 || !window.currentPerlinData1.xData) {
        return -1;
    }
    
    const frequencies = window.currentPerlinData1.xData;
    let nearestIndex = 0;
    let minDifference = Math.abs(frequencies[0] - targetFreq);
    
    for (let i = 1; i < frequencies.length; i++) {
        const difference = Math.abs(frequencies[i] - targetFreq);
        if (difference < minDifference) {
            minDifference = difference;
            nearestIndex = i;
        }
    }
    
    // 验证索引是否在有效范围内
    if (nearestIndex >= 0 && nearestIndex < frequencies.length) {
        console.log(`频率匹配(热力图1): 原始=${targetFreq} Hz, 匹配=${frequencies[nearestIndex]} Hz, 索引=${nearestIndex}, 数组长度=${frequencies.length}`);
        return nearestIndex;
    } else {
        console.log(`❌ 频率匹配(热力图1)索引越界: 原始=${targetFreq} Hz, 计算索引=${nearestIndex}, 数组长度=${frequencies.length}`);
        console.log(`🔍 热力图1频率范围: ${frequencies[0]}-${frequencies[frequencies.length-1]} Hz`);
        return -1;
    }
}

// 查找第二个热力图中最近的频率索引（3000-6000Hz）
function findNearestFrequencyIndex2(targetFreq) {
    if (!window.currentPerlinData2 || !window.currentPerlinData2.xData) {
        return -1;
    }
    
    const frequencies = window.currentPerlinData2.xData;
    let nearestIndex = 0;
    let minDifference = Math.abs(frequencies[0] - targetFreq);
    
    for (let i = 1; i < frequencies.length; i++) {
        const difference = Math.abs(frequencies[i] - targetFreq);
        if (difference < minDifference) {
            minDifference = difference;
            nearestIndex = i;
        }
    }
    
    // 验证索引是否在有效范围内
    if (nearestIndex >= 0 && nearestIndex < frequencies.length) {
        console.log(`频率匹配(热力图2): 原始=${targetFreq} Hz, 匹配=${frequencies[nearestIndex]} Hz, 索引=${nearestIndex}, 数组长度=${frequencies.length}`);
        return nearestIndex;
    } else {
        console.log(`❌ 频率匹配(热力图2)索引越界: 原始=${targetFreq} Hz, 计算索引=${nearestIndex}, 数组长度=${frequencies.length}`);
        console.log(`🔍 热力图2频率范围: ${frequencies[0]}-${frequencies[frequencies.length-1]} Hz`);
        return -1;
    }
}

// 根据检测数据更新热力图
function updateHeatmapFromDetection() {
    if (!myChart || !myChart2) {
        return;
    }
    
    // 获取当前图表的数据
    const currentData1 = myChart.getOption().series[0].data;
    const currentData2 = myChart2.getOption().series[0].data;
    let hasChanges1 = false;
    let hasChanges2 = false;
    let updatedCells = [];
    
    // 计算当前最大检出次数
    let maxDetectionCount = 0;
    for (const key in uavDetectionCounts) {
        if (uavDetectionCounts[key] > maxDetectionCount) {
            maxDetectionCount = uavDetectionCounts[key];
        }
    }
    
    // 更新第一个热力图的数据点（0-3000Hz）
    console.log('🔄 开始更新第一个热力图数据...');
    for (let i = 0; i < currentData1.length; i++) {
        const [freqIndex, uavIndex] = currentData1[i];
        const key = `1_${freqIndex}_${uavIndex}`;
        const detectionCount = uavDetectionCounts[key] || 0;
        
        // 使用统一的归一化函数
        const normalizedValue = normalizeDetectionCount(detectionCount);
        const oldValue = currentData1[i][2];
        
        // 更新数据点
        currentData1[i][2] = normalizedValue;
        
        // 检查是否有变化
        if (Math.abs(oldValue - normalizedValue) > 0.001) {
            hasChanges1 = true;
            // 安全检查索引范围
            if (freqIndex >= 0 && freqIndex < window.currentPerlinData1.xData.length && 
                uavIndex >= 0 && uavIndex < window.currentPerlinData1.yData.length) {
                const freqValue = window.currentPerlinData1.xData[freqIndex];
                const uavName = window.currentPerlinData1.yData[uavIndex];
                if (detectionCount > 0) {
                    updatedCells.push(`热力图1: ${uavName} @ ${freqValue}Hz`);
                    console.log(`✅ 热力图1更新: ${uavName} @ ${freqValue}Hz = ${detectionCount}次`);
                }
            } else {
                console.log(`⚠️ 热力图1索引越界: freqIndex=${freqIndex}, uavIndex=${uavIndex}`);
            }
        }
    }
    
    // 更新第二个热力图的数据点（3000-6000Hz）
    console.log('🔄 开始更新第二个热力图数据...');
    for (let i = 0; i < currentData2.length; i++) {
        const [freqIndex, uavIndex] = currentData2[i];
        const key = `2_${freqIndex}_${uavIndex}`;
        const detectionCount = uavDetectionCounts[key] || 0;
        
        // 使用统一的归一化函数
        const normalizedValue = normalizeDetectionCount(detectionCount);
        const oldValue = currentData2[i][2];
        
        // 更新数据点
        currentData2[i][2] = normalizedValue;
        
        // 检查是否有变化
        if (Math.abs(oldValue - normalizedValue) > 0.001) {
            hasChanges2 = true;
            // 安全检查索引范围
            if (freqIndex >= 0 && freqIndex < window.currentPerlinData2.xData.length && 
                uavIndex >= 0 && uavIndex < window.currentPerlinData2.yData.length) {
                const freqValue = window.currentPerlinData2.xData[freqIndex];
                const uavName = window.currentPerlinData2.yData[uavIndex];
                if (detectionCount > 0) {
                    updatedCells.push(`热力图2: ${uavName} @ ${freqValue}Hz`);
                    console.log(`✅ 热力图2更新: ${uavName} @ ${freqValue}Hz = ${detectionCount}次`);
                }
            } else {
                console.log(`⚠️ 热力图2索引越界: freqIndex=${freqIndex}, uavIndex=${uavIndex}`);
            }
        }
    }
    
    // 显示当前检测数据统计
    console.log('📊 当前检测数据统计:');
    let totalDetections = 0;
    for (const key in uavDetectionCounts) {
        if (uavDetectionCounts[key] > 0) {
            totalDetections += uavDetectionCounts[key];
            console.log(`  - ${key}: ${uavDetectionCounts[key]}次`);
        }
    }
    console.log(`📈 总检测次数: ${totalDetections}`);
    console.log(`🔄 热力图1变化: ${hasChanges1}, 热力图2变化: ${hasChanges2}`);
    console.log(`⏰ 当前时间: ${new Date().toLocaleTimeString()}`);
    console.log(`📊 两个热力图将同步更新，确保刷新速度一致`);
    
    // 只有在有变化时才更新图表
    if (hasChanges1 || hasChanges2) {
        // 计算实际的最大和最小检出次数
        let actualMaxCount = 0;
        let actualMinCount = 0;
        let hasValidData = false;
        
        for (const key in uavDetectionCounts) {
            if (uavDetectionCounts[key] > 0) {
                if (!hasValidData) {
                    actualMinCount = uavDetectionCounts[key];
                    hasValidData = true;
                }
                actualMaxCount = Math.max(actualMaxCount, uavDetectionCounts[key]);
                actualMinCount = Math.min(actualMinCount, uavDetectionCounts[key]);
            }
        }
        
        // 如果没有有效数据，使用默认值
        if (!hasValidData) {
            actualMaxCount = 1;
            actualMinCount = 0;
        }
        
        // 获取当前拖动条设置，保持用户设置的下限
        const currentOption1 = myChart.getOption();
        const currentVisualMap1 = currentOption1.visualMap[0];
        const userSetMin1 = currentVisualMap1.range ? currentVisualMap1.range[0] : actualMinCount;
        
        const currentOption2 = myChart2.getOption();
        const currentVisualMap2 = currentOption2.visualMap[0];
        const userSetMin2 = currentVisualMap2.range ? currentVisualMap2.range[0] : actualMinCount;
        
        // 同步更新两个热力图，确保刷新速度一致
        // 更新第一个热力图
        myChart.setOption({
            visualMap: {
                min: actualMinCount,
                max: actualMaxCount,
                range: [userSetMin1, actualMaxCount], // 保持用户设置的下限，只更新上限
                precision: 0, // 确保显示整数，不显示小数
                text: [`${Math.round(actualMaxCount)}次`, `${Math.round(userSetMin1)}次`]
            },
            series: [{
                data: currentData1
            }]
        }, {
            notMerge: false,
            lazyUpdate: false,
            silent: false,
            animation: true
        });
        
        // 更新第二个热力图
        myChart2.setOption({
            visualMap: {
                min: actualMinCount,
                max: actualMaxCount,
                range: [userSetMin2, actualMaxCount], // 保持用户设置的下限，只更新上限
                precision: 0, // 确保显示整数，不显示小数
                text: [`${Math.round(actualMaxCount)}次`, `${Math.round(userSetMin2)}次`]
            },
            series: [{
                data: currentData2
            }]
        }, {
            notMerge: false,
            lazyUpdate: false,
            silent: false,
            animation: true
        });
        


        
        // 更新表格显示
        updateDetectionTable();
        
        console.log('🎨 热力图已同步更新以下格子:');
        updatedCells.forEach(cell => {
            console.log(`  - ${cell}`);
        });
        console.log(`📊 拉动条上限已更新为: ${actualMaxCount}`);
        console.log('✅ 两个热力图同步更新完成');
        console.log('📊 检出统计表已同步更新');
    } else {
        console.log('⏭️ 无数据变化，跳过更新');
    }
}

function handleWebSocketData(data) {
    // 简单打印接收到的数据
    //console.log('收到WebSocket数据:', data);
    try {
        if(data.msg == "UAV_OBJECT"){
            // 处理无人机检测数据
            console.log('收到无人机检测数据:', data);
            handleUavObject(data);
        } else if(data.msg == "UAV_LIB") {
            // 处理无人机库数据响应
            console.log('收到无人机库数据:', data);
            // 提取无人机名称
            extractUavNames(data);
        }
    } catch (error) {
        console.log('接收到的非JSON数据:', data);
        // 处理非JSON格式的数据
    }
}

// 提取无人机名称并保存到全局变量
function extractUavNames(data) {
    if (data.msg === 'UAV_LIB' && data.uavDetectTemplate && Array.isArray(data.uavDetectTemplate)) {
        // 保存完整的无人机库数据到全局变量
        globalUavLib = data.uavDetectTemplate;
        
        // 提取所有无人机名称并保存到全局变量
        globalUavNames = data.uavDetectTemplate.map(uav => uav.name || '未命名');
        
        console.log('=== 无人机库数据已保存到全局变量 ===');
        console.log('总数量:', globalUavNames.length);
        console.log('名称数组:', globalUavNames);
        console.log('完整数据已保存到 globalUavLib');
        console.log('');
        
        // 按序号显示每个名称
        globalUavNames.forEach((name, index) => {
            console.log(`${index + 1}. ${name}`);
        });
        
        console.log('=== 无人机库名称列表结束 ===');
        console.log('💾 数据已保存到全局变量:');
        console.log('   - globalUavLib: 完整无人机库数据');
        console.log('   - globalUavNames: 无人机名称数组');
        
        // 更新热力图的纵坐标
        updateHeatmapYAxis();
        
        return globalUavNames;
    } else {
        console.log('❌ 数据格式错误，无法提取无人机名称');
        console.log('数据:', data);
        return [];
    }
}

// 更新热力图的纵坐标
function updateHeatmapYAxis() {
    if (myChart && myChart2 && globalUavNames && globalUavNames.length > 0) {
        // 生成空白数据以适应新的纵坐标
        const perlinData1 = generateEmptyData1();
        const perlinData2 = generateEmptyData2();
        
        // 更新全局变量
        window.currentPerlinData1 = perlinData1;
        window.currentPerlinData2 = perlinData2;
        
        // 更新第一个图表
        myChart.setOption({
            yAxis: {
                data: perlinData1.yData
            },
            series: [{
                data: perlinData1.data
            }]
        });
        
        // 更新第二个图表
        myChart2.setOption({
            yAxis: {
                data: perlinData2.yData
            },
            series: [{
                data: perlinData2.data
            }]
        });
        
        console.log('✅ 两个热力图纵坐标已更新为无人机名称');
        console.log('新的纵坐标:', perlinData1.yData);
    }
}

// 获取无人机库数据
function getUavLib() {
    if (websocket && isConnected) {
        const message = JSON.stringify({ msg: 'getUavLib' });
        sendWebSocketMessage(message);
        console.log('发送获取无人机库请求');
    } else {
        console.warn('WebSocket未连接，无法获取无人机库数据');
        alert('请先连接到服务器');
    }
}







// 定时更新热力图
function startAutoUpdate() {
    if (updateTimer) {
        clearInterval(updateTimer);
    }
    
    updateTimer = setInterval(() => {
        console.log('⏰ 定时更新热力图...');
        console.log('📊 当前检测数据统计:');
        
        // 显示当前检测数据统计
        let totalDetections = 0;
        for (const key in uavDetectionCounts) {
            if (uavDetectionCounts[key] > 0) {
                totalDetections += uavDetectionCounts[key];
                const parts = key.split('_');
                if (parts.length === 3) {
                    const chartType = parts[0];
                    const freqIndex = parseInt(parts[1]);
                    const uavIndex = parseInt(parts[2]);
                    
                    let freqValue, uavName;
                    if (chartType === '1') {
                        // 安全检查索引范围
                        if (freqIndex >= 0 && freqIndex < window.currentPerlinData1.xData.length && 
                            uavIndex >= 0 && uavIndex < window.currentPerlinData1.yData.length) {
                            freqValue = window.currentPerlinData1.xData[freqIndex];
                            uavName = window.currentPerlinData1.yData[uavIndex];
                        }
                    } else if (chartType === '2') {
                        // 安全检查索引范围
                        if (freqIndex >= 0 && freqIndex < window.currentPerlinData2.xData.length && 
                            uavIndex >= 0 && uavIndex < window.currentPerlinData2.yData.length) {
                            freqValue = window.currentPerlinData2.xData[freqIndex];
                            uavName = window.currentPerlinData2.yData[uavIndex];
                        }
                    }
                    
                    if (freqValue && uavName) {
                        console.log(`  - 热力图${chartType}: ${uavName} @ ${freqValue}Hz: ${uavDetectionCounts[key]}次`);
                    } else {
                        console.log(`⚠️ 热力图${chartType}索引越界: freqIndex=${freqIndex}, uavIndex=${uavIndex}`);
                    }
                }
            }
        }
        console.log(`📈 总检测次数: ${totalDetections}`);
        
        updateHeatmapFromDetection();
    }, updateInterval);
    
    console.log(`✅ 已启动定时更新，间隔: ${updateInterval/1000}秒`);
}

// 停止定时更新
function stopAutoUpdate() {
    if (updateTimer) {
        clearInterval(updateTimer);
        updateTimer = null;
        console.log('⏹️ 已停止定时更新');
    }
}

// 设置更新间隔
function setUpdateInterval(seconds) {
    updateInterval = seconds * 1000;
    if (updateTimer) {
        // 如果定时器正在运行，重新启动以应用新的间隔
        startAutoUpdate();
    }
    console.log(`⚙️ 更新间隔已设置为: ${seconds}秒`);
}

// 更新检出统计表格
function updateDetectionTable() {
    const tableBody = document.getElementById('detectionTableBody');
    
    console.log('🔄 开始更新检出统计表格...');
    console.log(`📊 当前数据统计: uavDetectionCounts=${Object.keys(uavDetectionCounts).length}个, freqDetectionCounts=${Object.keys(freqDetectionCounts).length}个`);
    
    // 清空表格内容
    tableBody.innerHTML = '';
    
    // 检查是否有检测数据
    if (Object.keys(freqDetectionCounts).length === 0) {
        // 显示空状态
        const emptyRow = document.createElement('tr');
        emptyRow.className = 'empty-row';
        emptyRow.innerHTML = '<td colspan="4">暂无检出数据</td>';
        tableBody.appendChild(emptyRow);
        return;
    }
    
    // 收集所有检测数据（使用具体频点的检测次数）
    const detectionData = [];
    console.log(`🔍 开始遍历freqDetectionCounts，共${Object.keys(freqDetectionCounts).length}个键`);
    
    for (const freqKey in freqDetectionCounts) {
        console.log(`🔍 检查键: ${freqKey}, 值: ${freqDetectionCounts[freqKey]}`);
        if (freqDetectionCounts[freqKey] > 0) {
            const parts = freqKey.split('|||');
            if (parts.length === 2) {
                // 从freqKey中提取无人机名称和频点
                const uavName = parts[0];
                const freqValue = parseInt(parts[1]); // 现在存储的值已经是正确的MHz值
                
                console.log(`🔍 解析freqKey: "${freqKey}" -> 无人机:"${uavName}", 频点:${freqValue}`);
                
                // 查找对应的热力图类型和索引
                let chartType = '';
                let freqIndex = -1;
                let uavIndex = -1;
                
                    // 在第一个热力图中查找
    if (window.currentPerlinData1 && window.currentPerlinData1.xData && window.currentPerlinData1.yData) {
        freqIndex = window.currentPerlinData1.xData.indexOf(freqValue);
        uavIndex = window.currentPerlinData1.yData.indexOf(uavName);
        console.log(`🔍 热力图1查找: 频点${freqValue}MHz -> 索引${freqIndex}, 无人机${uavName} -> 索引${uavIndex}`);
        if (freqIndex !== -1 && uavIndex !== -1) {
            chartType = '1';
        }
    }
                
                    // 如果在第一个热力图中没找到，在第二个热力图中查找
    if (chartType === '' && window.currentPerlinData2 && window.currentPerlinData2.xData && window.currentPerlinData2.yData) {
        freqIndex = window.currentPerlinData2.xData.indexOf(freqValue);
        uavIndex = window.currentPerlinData2.yData.indexOf(uavName);
        console.log(`🔍 热力图2查找: 频点${freqValue}MHz -> 索引${freqIndex}, 无人机${uavName} -> 索引${uavIndex}`);
        if (freqIndex !== -1 && uavIndex !== -1) {
            chartType = '2';
        }
    }
                
                // 如果找到了对应的位置，添加到表格数据中
                if (chartType !== '' && freqIndex !== -1 && uavIndex !== -1) {
                    // 计算Similarity平均值
                    const avgSimilarity = freqSimilaritySums[freqKey] / freqDetectionCounts[freqKey];
                    
                    detectionData.push({
                        uavName: uavName,
                        freqValue: freqValue,
                        freqIndex: freqIndex,
                        uavIndex: uavIndex,
                        chartType: chartType,
                        detectionCount: freqDetectionCounts[freqKey], // 使用具体频点的检测次数
                        avgSimilarity: avgSimilarity // 添加Similarity平均值
                    });
                    console.log(`✅ 添加到表格数据: ${uavName} @ ${freqValue}MHz = ${freqDetectionCounts[freqKey]}次, 平均相似度: ${avgSimilarity.toFixed(1)}`);
                } else {
                    console.log(`⚠️ 无法找到频点 ${freqValue}MHz 对应的热力图位置`);
                    console.log(`🔍 调试信息: chartType=${chartType}, freqIndex=${freqIndex}, uavIndex=${uavIndex}`);
                }
            }
        }
    }
    
    // 按检出次数降序排序
    detectionData.sort((a, b) => b.detectionCount - a.detectionCount);
    
    console.log(`📊 表格更新: 共找到 ${detectionData.length} 条检测记录`);
    detectionData.forEach((data, index) => {
        console.log(`  ${index + 1}. ${data.uavName} @ ${data.freqValue}Hz: ${data.detectionCount}次`);
    });
    
    // 生成表格行
    console.log(`📋 开始生成${detectionData.length}行表格数据`);
    detectionData.forEach((data, index) => {
        const row = document.createElement('tr');
        
        // 根据检出次数确定CSS类，与热力图颜色映射保持一致
        let countClass = 'low';
        if (data.detectionCount >= 500) {
            countClass = 'very-high'; // 500次以上：深红色
        } else if (data.detectionCount >= 200) {
            countClass = 'high'; // 200-500次：红色
        } else if (data.detectionCount >= 50) {
            countClass = 'medium-high'; // 50-200次：橙色
        } else if (data.detectionCount >= 10) {
            countClass = 'medium'; // 10-50次：黄色
        } else if (data.detectionCount >= 1) {
            countClass = 'low'; // 1-10次：蓝色
        }
        
        row.innerHTML = `
            <td>${data.uavName}</td>
            <td>${data.freqValue} MHz</td>
            <td class="detection-count ${countClass}">${data.detectionCount}</td>
            <td class="similarity-value">${data.avgSimilarity.toFixed(1)}</td>
        `;
        
        tableBody.appendChild(row);
        console.log(`✅ 已添加第${index + 1}行: ${data.uavName} @ ${data.freqValue}Hz = ${data.detectionCount}次`);
    });
    
    console.log(`✅ 表格更新完成，共添加${detectionData.length}行数据`);
}

// 启动表格定时更新
function startTableUpdate() {
    if (tableUpdateTimer) {
        clearInterval(tableUpdateTimer);
    }
    
    // 立即更新一次
    updateDetectionTable();
    
    // 每秒更新一次
    tableUpdateTimer = setInterval(() => {
        updateDetectionTable();
    }, 1000);
    
    console.log('📊 表格定时更新已启动，每秒刷新一次');
}

// 停止表格定时更新
function stopTableUpdate() {
    if (tableUpdateTimer) {
        clearInterval(tableUpdateTimer);
        tableUpdateTimer = null;
        console.log('⏹️ 表格定时更新已停止');
    }
}





// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', function() {
    initHeatmap();
    
    // 启动表格定时更新
    startTableUpdate();
    
    // 绑定按钮事件
    document.getElementById('clearData').addEventListener('click', clearData);
    document.getElementById('getUavLibBtn').addEventListener('click', getUavLib);



    
    // 绑定定时更新按钮事件
    document.getElementById('startAutoUpdateBtn').addEventListener('click', startAutoUpdate);
    document.getElementById('stopAutoUpdateBtn').addEventListener('click', stopAutoUpdate);
    document.getElementById('setIntervalBtn').addEventListener('click', function() {
        const interval = parseInt(document.getElementById('updateIntervalInput').value);
        if (interval >= 1 && interval <= 60) {
            setUpdateInterval(interval);
        } else {
            alert('请输入1-60之间的数字');
        }
    });
    
    // 绑定全频段扫描无人机按钮事件
    document.getElementById('fullBandScanBtn').addEventListener('click', function() {
        console.log('🚁 全频段扫描无人机功能已触发');
        setWorkMode('UAV_DETECT_MODE');
        alert('全频段扫描无人机功能已启动');
    });

    
    // 绑定WebSocket按钮事件
    document.getElementById('connectBtn').addEventListener('click', connectWebSocket);
    document.getElementById('disconnectBtn').addEventListener('click', disconnectWebSocket);
    
    // 响应式处理
    window.addEventListener('resize', function() {
        if (myChart) {
            myChart.resize();
        }
        if (myChart2) {
            myChart2.resize();
        }
    });
});
